﻿#include <iostream>
using namespace std;

//class Person
//{
//public:
//	virtual void BuyTicket() //virtual修饰的成员函数是虚函数
//	{
//		cout << "买票-全价" << endl;
//	}
//};
//
//class Student : public Person
//{
//public:
//	virtual void BuyTicket() //重写虚函数
//	{
//		cout << "买票-打折" << endl;
//	}
//};
//
//int main()
//{
//	Person p1;
//	Student s1;
//
//	//用基类的指针或引用来调用重写的虚函数
//	Person* ptr1 = &p1;
//	Person* ptr2 = &s1;
//
//	ptr1->BuyTicket();
//	ptr2->BuyTicket();
//
//	cout << endl;
//
//	Person& r1 = p1;
//	Person& r2 = s1;
//
//	r1.BuyTicket();
//	r2.BuyTicket();
//
//	return 0;
//}

//class A
//{
//public:
//	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
//	virtual void test() { func(); }
//};
//
//class B : public A
//{
//public:
//	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
//};
//
//int main(int argc, char* argv[])
//{
//	B* p = new B;
//	p->test();
//	p->func();
//	return 0;
//}

//协变
//class Person
//{
//public:
//	virtual Person* BuyTicket() //基类 返回其它基类或者当前基类的指针或引用
//	{
//		cout << "买票-全价" << endl;
//		return nullptr;
//	}
//};
//
//class Student : public Person
//{
//public:
//	virtual Student* BuyTicket() //派生类 返回其它派生类或者当前派生类的指针或引用
//	{
//		cout << "买票-打折" << endl;
//		return nullptr;
//	}
//};
//
//int main()
//{
//	Person p;
//	Student s;
//
//	Person* ptr1 = &p;
//	Person* ptr2 = &s;
//
//	ptr1->BuyTicket();
//	ptr1->BuyTicket();
//	return 0;
//}

//class A
//{
//public:
//	virtual ~A()
//	{
//		cout << "~A()" << endl;
//	}
//};
//
//class B : public A
//{
//public:
//	~B()
//	{
//		cout << "~B()" << endl;
//		delete _ptr;
//		_ptr = nullptr;
//	}
//private:
//	int* _ptr = new int[5];
//};
//
//int main()
//{
//	A* ptr1 = new A;
//	A* ptr2 = new B;
//
//  //析构在编译时会被处理为destructor(),所以实际上所有的析构函数都是同名的
//	delete ptr1;
//	delete ptr2;
//
//	return 0;
//}

//class Person
//{
//public:
//	virtual final void BuyTicket() //final 修饰的虚函数不能重写
//	{
//		cout << "买票-全价" << endl;
//	}
//};
//
//class Student : public Person
//{
//public:
//	virtual void BuyTicket() override //override检测是否重写
//	{
//		cout << "买票-打折" << endl;
//	}
//};
//
//int main()
//{
//	return 0;
//}

//class Person
//{
//public:
//	virtual void BuyTicket() = 0; //纯虚函数，类为抽象类
//};
//
//class Student : public Person
//{
//public:
//	//派生类不重写纯虚函数，也是抽象类
//	virtual void BuyTicket()
//	{
//		cout << "买票-降价" << endl;
//	}
//};
//
//int main()
//{
//	//Person p; //抽象类无法实例化对象
//
//	Student s;
//
//	return 0;
//}

//class Base
//{
//public:
//	virtual void Func1()
//	{
//		cout << "Func1()" << endl;
//	}
//protected:
//	int _b = 1;
//	char _ch = 'x';
//};
//
//int main()
//{
//	Base b;
//	cout << sizeof(b) << endl;
//	return 0;
//}

//class Person
//{
//public:
//	virtual void BuyTicket()
//	{
//		cout << "买票-全价" << endl;
//	}
//private:
//	string _name;
//};
//
//class Student : public Person
//{
//public:
//	virtual void BuyTicket()
//	{
//		cout << "买票-降价" << endl;
//	}
//
//	//virtual void SellTicket()
//	//{
//	//	cout << "卖票" << endl;
//	//}
//private:
//	string _id;
//};
//
//class Soldier : public Person
//{
//public:
//	virtual void BuyTicket()
//	{
//		cout << "买票-优先" << endl;
//	}
//private:
//	string _codeName;
//};
//
//void Print(Person& person)
//{
//	person.BuyTicket();
//}
//
//int main()
//{
//	Person person;
//	Person person2;
//	Student student;
//	Soldier soldier;
//
//	//满足多态时，运行的时候会到指向的对象中的虚函数表内查找虚函数的地址，根据地址找到虚函数
//	Print(person);
//	Print(student);
//	Print(soldier);
//
//	return 0;
//}

//class Base {
//public:
//	virtual void func1() { cout << "Base::func1" << endl; }
//	virtual void func2() { cout << "Base::func2" << endl; }
//	void func5() { cout << "Base::func5" << endl; }
//protected:
//	int a = 1;
//};
//class Derive : public Base
//{
//public:
//	// 重写基类的func1
//	virtual void func1() { cout << "Derive::func1" << endl; }
//	virtual void func3() { cout << "Derive::func1" << endl; }
//	void func4() { cout << "Derive::func4" << endl; }
//protected:
//	int b = 2;
//};
//
//
//int main()
//{
//	int i = 0;
//	static int j = 1;
//	int* p1 = new int;
//	const char* p2 = "xxxxxxxx";
//	printf("栈:%p\n", &i);
//	printf("静态区:%p\n", &j);
//	printf("堆:%p\n", p1);
//	printf("常量区:%p\n", p2);
//
//	Base b;
//	Derive d;
//	Base* p3 = &b;
//	Derive* p4 = &d;
//	printf("Person虚表地址:%p\n", *(int*)p3);
//	printf("Student虚表地址:%p\n", *(int*)p4);
//	printf("虚函数地址:%p\n", &Base::func1);
//	printf("普通函数地址:%p\n", &Base::func5);
//
//	return 0;
//}

//class A
//{ 
//public: 
//	void test(float a) 
//	{ 
//		cout << a; 
//	}
//}; 
//
//class B :public A
//{ 
//public: 
//	void test(int b) 
//	{ 
//		cout << b; 
//	}
//}; 
//
//void main() 
//{ 
//	A *a = new A; 
//	B *b = new B; 
//	a = b; 
//	a->test(1.1); 
//}

//class A
//{
//public:
//	void f1() { cout << "A::f1()" << endl; }
//	virtual void f2() { cout << "A::f2()" << endl; }
//	virtual void f3() { cout << "A::f3()" << endl; }
//};
//
//class B : public A
//{
//public:
//	virtual void f1() { cout << "B::f1()" << endl; }
//	virtual void f2() { cout << "B::f2()" << endl; }
//	void f3() { cout << "B::f3()" << endl; }
//};

//class A
//{
//public:
//    virtual void f()
//    {
//        cout << "A::f()" << endl;
//    }
//};
//
//class B : public A
//{
//private:
//    virtual void f()
//    {
//        cout << "B::f()" << endl;
//    }
//};
//
//int main()
//{
//    A* pa = (A*)new B;
//    pa->f();
//    return 0;
//}

//class A
//{
//public:
//    A() 
//        :m_iVal(0) 
//    { 
//        test(); 
//    }
//    virtual void func() 
//    { 
//        std::cout << m_iVal << " "; 
//    }
//    void test()
//    { 
//        func(); 
//    }
//public:
//    int m_iVal;
//};
//
//class B : public A
//{
//public:
//    B() 
//    { 
//        test(); 
//    }
//    virtual void func()
//    {
//        ++m_iVal;
//        std::cout << m_iVal << " ";
//    }
//};
//
//int main(int argc, char* argv[])
//{
//    A* p = new B;
//    p->test();
//    return 0;
//}

class A
{
public:
	virtual void funcA()
	{
		cout << "A()" << endl;
	}
};

class B
{
public:
	virtual void funcB()
	{
		cout << "B()" << endl;
	}
};

class C : public A, public B
{
public:
	virtual void funcA()
	{
		cout << "A()" << endl;
	}

	virtual void funcB()
	{
		cout << "B()" << endl;
	}

	virtual void funcC()
	{
		cout << "C()" << endl;
	}
};

int main()
{
	C c;
	return 0;
}